﻿using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using System.Collections.Generic;
using XNAFight.Engine;
using XNAFight.Characters.Core;
using Microsoft.Xna.Framework.Content;

namespace XNAFight.Characters
{
    
    public class Ryu : Character
    {

        public Ryu(ContentManager _ContentManager, Vector2 _pos_depart)
            : base(_ContentManager, _pos_depart)
        {
            name = "Ryu";
            Vie_max = 1000;
            Stun_max = 1000;
            int priorite = 0;

            
            // J'ai essayé de regarder un peu comment se comporte Ryu dans SF3 et j'ai essayé de reproduire un peu les mêmes vitesses et distances de dash
            Vitesse_marche = new Vector2(3.5f, 0.0f);
            Vitesse_marche_recule = new Vector2(2.5f, 0.0f);
            dash.Distance = 90;
            backdash.Distance = -55;
            dash.FrameDuration = 18;
            backdash.FrameDuration = 10;
                    
            Alive = true;

            Vector2 origineDefaut = new Vector2(145f,159f);

            // Animations
            // ----------------

            // mouvements de base
            AnimationList.Add(new AnimationData("Stand", "characters/Ryu/sprite_ryu_stand", 10, 0, 290, origineDefaut, true, false, 0.5f));
            AnimationList.Add(new AnimationData("Crouch", "characters/Ryu/sprite_ryu_crouch", 4, 0, 290, origineDefaut, true, false, 0.8f));
            AnimationList.Add(new AnimationData("Standing", "characters/Ryu/sprite_ryu_crouching", 3, 0, 290, origineDefaut, false, true, 0.06f));
            AnimationList.Add(new AnimationData("Crouching", "characters/Ryu/sprite_ryu_crouching", 3, 0, 290, origineDefaut, false, false, 0.06f));
            AnimationList.Add(new AnimationData("BWalk", "characters/Ryu/sprite_ryu_walk_back", 11, 0, 290, origineDefaut, true, false, 0.55f));
            AnimationList.Add(new AnimationData("FWalk", "characters/Ryu/sprite_ryu_walk_forward", 11, 0, 290, origineDefaut, true, false, 0.55f));

            // dash
            AnimationList.Add(new AnimationData("Dash", "characters/Ryu/sprite_ryu_dash", 6, 0, 290, origineDefaut, false, false, (float)dash.FrameDuration / 60f));
            AnimationList.Add(new AnimationData("Backdash", "characters/Ryu/sprite_ryu_backdash", 6, 0, 290, origineDefaut, false, false, (float)dash.FrameDuration / 60f));
            
            // sauts
            AnimationList.Add(new AnimationData("UJump", "characters/Ryu/sprite_ryu_ujump", 12, 0, 290, origineDefaut, false, false, (float)ujump.FrameDuration / 60f));
            AnimationList.Add(new AnimationData("FJump", "characters/Ryu/sprite_ryu_fjump", 15, 0, 290, origineDefaut, false, false, (float)fjump.FrameDuration / 60f));
            AnimationList.Add(new AnimationData("BJump", "characters/Ryu/sprite_ryu_fjump", 15, 0, 290, origineDefaut, false, true, (float)bjump.FrameDuration / 60f));

            // coups
            AnimationList.Add(new AnimationData("HP_far", "characters/Ryu/sprite_ryu_hp_far", 11, 0, 290, origineDefaut, false, false, 0.55f));

            AnimationEnCours = "Stand";
            // ---------------
            
            #region NORMAUX

            // Il faut ajouter un tag crouch aux coups qui ne peuvent sortir qu'avec un perso en crouch
            #region CROUCH
            BMoveSequence c_lp = new BMoveSequence();
            c_lp.Coup = new Coup("LP -Crouch-", priorite, true, false, false);
            c_lp.Add(0, BMove.LPUNCH);
            Sequences.Add(c_lp);
            priorite++;

            BMoveSequence c_lk = new BMoveSequence();
            c_lk.Coup = new Coup("LK -Crouch-", priorite, true, false, false);
            c_lk.Add(0, BMove.LKICK);
            Sequences.Add(c_lk);
            priorite++;

            BMoveSequence c_mp = new BMoveSequence();
            c_mp.Coup = new Coup("MP -Crouch-", priorite, true, false, false);
            c_mp.Add(0, BMove.MPUNCH);
            Sequences.Add(c_mp);
            priorite++;

            BMoveSequence c_mk = new BMoveSequence();
            c_mk.Coup = new Coup("MK -Crouch-", priorite, true, false, false);
            c_mk.Add(0, BMove.MKICK);
            Sequences.Add(c_mk);
            priorite++;

            BMoveSequence c_hp = new BMoveSequence();
            c_hp.Coup = new Coup("HP -Crouch-", priorite, true, false, false);
            c_hp.Add(0, BMove.HPUNCH);
            Sequences.Add(c_hp);
            priorite++;

            BMoveSequence c_hk = new BMoveSequence();
            c_hk.Coup = new Coup("HK -Crouch-", priorite, true, false, false);
            c_hk.Add(0, BMove.HKICK);
            Sequences.Add(c_hk);
            priorite++;
            #endregion

            #region STAND
            BMoveSequence lp = new BMoveSequence();
            lp.Coup = new Coup("LP -Stand-", priorite, false, false, true);
            lp.Add(0, BMove.LPUNCH);
            Sequences.Add(lp);
            priorite++;

            BMoveSequence lk = new BMoveSequence();
            lk.Coup = new Coup("LK -Stand-", priorite, false, false, true);
            lk.Add(0, BMove.LKICK);
            Sequences.Add(lk);
            priorite++;

            BMoveSequence mp = new BMoveSequence();
            mp.Coup = new Coup("MP -Stand-", priorite, false, false, true);
            mp.Add(0, BMove.MPUNCH);
            Sequences.Add(mp);
            priorite++;

            BMoveSequence mk = new BMoveSequence();
            mk.Coup = new Coup("MK -Stand-", priorite, false, false, true);
            mk.Add(0, BMove.MKICK);
            Sequences.Add(mk);
            priorite++;

            BMoveSequence hp = new BMoveSequence();
            hp.Coup = new Coup("HP -Stand-", priorite, false, false, true, "HP_far");
            hp.Add(0, BMove.HPUNCH);
            Sequences.Add(hp);
            priorite++;

            BMoveSequence hk = new BMoveSequence();
            hk.Coup = new Coup("HK -Stand-", priorite, false, false, true);
            hk.Add(0, BMove.HKICK);
            Sequences.Add(hk);
            priorite++;
            #endregion

            // Il faut ajouter un tag air aux coups qui ne peuvent sortir qu'avec un perso en l'air
            #region AIR
            BMoveSequence a_lp = new BMoveSequence();
            a_lp.Coup = new Coup("LP -AIR-", priorite, false, true, false);
            a_lp.Add(0, BMove.LPUNCH);
            Sequences.Add(a_lp);
            priorite++;

            BMoveSequence a_lk = new BMoveSequence();
            a_lk.Coup = new Coup("LK -AIR-", priorite, false, true, false);
            a_lk.Add(0, BMove.LKICK);
            Sequences.Add(a_lk);
            priorite++;

            BMoveSequence a_mp = new BMoveSequence();
            a_mp.Coup = new Coup("MP -AIR-", priorite, false, true, false);
            a_mp.Add(0, BMove.MPUNCH);
            Sequences.Add(a_mp);
            priorite++;

            BMoveSequence a_mk = new BMoveSequence();
            a_mk.Coup = new Coup("MK -AIR-", priorite, false, true, false);
            a_mk.Add(0, BMove.MKICK);
            Sequences.Add(a_mk);
            priorite++;

            BMoveSequence a_hp = new BMoveSequence();
            a_hp.Coup = new Coup("HP -AIR-", priorite, false, true, false);
            a_hp.Add(0, BMove.HPUNCH);
            Sequences.Add(a_hp);
            priorite++;

            BMoveSequence a_hk = new BMoveSequence();
            a_hk.Coup = new Coup("HK -AIR-", priorite, false, true, false);
            a_hk.Add(0, BMove.HKICK);
            Sequences.Add(a_hk);
            priorite++;
            #endregion 

            #endregion

            #region COMMAND
            BMoveSequence collarbone = new BMoveSequence();
            collarbone.Coup = new Coup("Collarbone Breaker", priorite, true, false, true);
            collarbone.Add(0, BMove.FORWARD);
            collarbone.Add(0, BMove.MPUNCH);
            Sequences.Add(collarbone);
            priorite++;

            BMoveSequence solar = new BMoveSequence();
            solar.Coup = new Coup("Solar Plexus Strike", priorite, true, false, true);
            solar.Add(0, BMove.FORWARD);
            solar.Add(0, BMove.HPUNCH);
            Sequences.Add(solar);
            priorite++;
            #endregion

            #region THROW

            BMoveSequence neutral_throw = new BMoveSequence();
            neutral_throw.Coup = new Coup("Throw", priorite, true, false, true);
            neutral_throw.Add(0, BMove.LKICK);
            neutral_throw.Add(0, BMove.LPUNCH);
            Sequences.Add(neutral_throw);
            priorite++;

            BMoveSequence back_throw = new BMoveSequence();
            back_throw.Coup = new Coup("Back throw", priorite, true, false, true);
            back_throw.Add(0, BMove.BACK);
            back_throw.Add(0, BMove.LKICK);
            back_throw.Add(0, BMove.LPUNCH);
            Sequences.Add(back_throw);
            priorite++;

            #endregion

            #region FOCUS & TAUNT

            BMoveSequence focus = new BMoveSequence();
            focus.Coup = new Coup("Focus", priorite, true, false, true);
            focus.Add(0, BMove.MKICK);
            focus.Add(0, BMove.MPUNCH);
            Sequences.Add(focus);
            priorite++;

            BMoveSequence taunt = new BMoveSequence();
            taunt.Coup = new Coup("Taunt", priorite, true, false, true);
            taunt.Add(0, BMove.HKICK);
            taunt.Add(0, BMove.HPUNCH);
            Sequences.Add(taunt);
            priorite++;

            #endregion

            #region SPECIAUX

            #region AU SOL
            BMoveSequence tatsu_light = new BMoveSequence();
            tatsu_light.Coup = new Coup("Tatsu [LIGHT]", priorite, true, false, true);
            tatsu_light.Add(0, BMove.DOWN);
            tatsu_light.Add(1, BMove.DOWN_BACK);
            tatsu_light.Add(2, BMove.BACK);
            tatsu_light.Add(3, BMove.LKICK);
            Sequences.Add(tatsu_light);
            priorite++;

            BMoveSequence hadoken_light = new BMoveSequence();
            hadoken_light.Coup = new Coup("Hadoken [LIGHT]", priorite, true, false, true);
            hadoken_light.Add(0, BMove.DOWN);
            hadoken_light.Add(1, BMove.DOWN_FORWARD);
            hadoken_light.Add(2, BMove.FORWARD);
            hadoken_light.Add(3, BMove.LPUNCH);
            Sequences.Add(hadoken_light);
            priorite++;

            BMoveSequence shoryu_light = new BMoveSequence();
            shoryu_light.Coup = new Coup("Shoryuken [LIGHT]", priorite, true, false, true);
            shoryu_light.Add(0, BMove.FORWARD);
            shoryu_light.Add(1, BMove.DOWN);
            shoryu_light.Add(2, BMove.DOWN_FORWARD);
            shoryu_light.Add(3, BMove.LPUNCH);
            Sequences.Add(shoryu_light);
            priorite++;

            BMoveSequence tatsu_med = new BMoveSequence();
            tatsu_med.Coup = new Coup("Tatsu [MED]", priorite, true, false, true);
            tatsu_med.Add(0, BMove.DOWN);
            tatsu_med.Add(1, BMove.DOWN_BACK);
            tatsu_med.Add(2, BMove.BACK);
            tatsu_med.Add(3, BMove.MKICK);
            Sequences.Add(tatsu_med);
            priorite++;

            BMoveSequence hadoken_med = new BMoveSequence();
            hadoken_med.Coup = new Coup("Hadoken [MED]", priorite, true, false, true);
            hadoken_med.Add(0, BMove.DOWN);
            hadoken_med.Add(1, BMove.DOWN_FORWARD);
            hadoken_med.Add(2, BMove.FORWARD);
            hadoken_med.Add(3, BMove.MPUNCH);
            Sequences.Add(hadoken_med);
            priorite++;

            BMoveSequence shoryu_med = new BMoveSequence();
            shoryu_med.Coup = new Coup("Shoryuken [MED]", priorite, true, false, true);
            shoryu_med.Add(0, BMove.FORWARD);
            shoryu_med.Add(1, BMove.DOWN);
            shoryu_med.Add(2, BMove.DOWN_FORWARD);
            shoryu_med.Add(3, BMove.MPUNCH);
            Sequences.Add(shoryu_med);
            priorite++;

            BMoveSequence tatsu_high = new BMoveSequence();
            tatsu_high.Coup = new Coup("Tatsu [HIGH]", priorite, true, false, true);
            tatsu_high.Add(0, BMove.DOWN);
            tatsu_high.Add(1, BMove.DOWN_BACK);
            tatsu_high.Add(2, BMove.BACK);
            tatsu_high.Add(3, BMove.HKICK);
            Sequences.Add(tatsu_high);
            priorite++;

            BMoveSequence hadoken_high = new BMoveSequence();
            hadoken_high.Coup = new Coup("Hadoken [HIGH]", priorite, true, false, true);
            hadoken_high.Add(0, BMove.DOWN);
            hadoken_high.Add(1, BMove.DOWN_FORWARD);
            hadoken_high.Add(2, BMove.FORWARD);
            hadoken_high.Add(3, BMove.HPUNCH);
            Sequences.Add(hadoken_high);
            priorite++;

            BMoveSequence shoryu_high = new BMoveSequence();
            shoryu_high.Coup = new Coup("Shoryuken [HIGH]", priorite, true, false, true);
            shoryu_high.Add(0, BMove.FORWARD);
            shoryu_high.Add(1, BMove.DOWN);
            shoryu_high.Add(2, BMove.DOWN_FORWARD);
            shoryu_high.Add(3, BMove.HPUNCH);
            Sequences.Add(shoryu_high);
            priorite++;
            #endregion

            #region AIR
            BMoveSequence air_tatsu_light = new BMoveSequence();
            air_tatsu_light.Coup = new Coup("Tatsu [LIGHT] - Air -", priorite, false, true, false);
            air_tatsu_light.Add(0, BMove.DOWN);
            air_tatsu_light.Add(1, BMove.DOWN_BACK);
            air_tatsu_light.Add(2, BMove.BACK);
            air_tatsu_light.Add(3, BMove.LKICK);
            Sequences.Add(air_tatsu_light);
            priorite++;

            BMoveSequence air_tatsu_med = new BMoveSequence();
            air_tatsu_med.Coup = new Coup("Tatsu [MED] - Air -", priorite, false, true, false);
            air_tatsu_med.Add(0, BMove.DOWN);
            air_tatsu_med.Add(1, BMove.DOWN_BACK);
            air_tatsu_med.Add(2, BMove.BACK);
            air_tatsu_med.Add(3, BMove.MKICK);
            Sequences.Add(air_tatsu_med);
            priorite++;

            BMoveSequence air_tatsu_high = new BMoveSequence();
            air_tatsu_high.Coup = new Coup("Tatsu [HIGH] - Air -", priorite, false, true, false);
            air_tatsu_high.Add(0, BMove.DOWN);
            air_tatsu_high.Add(1, BMove.DOWN_BACK);
            air_tatsu_high.Add(2, BMove.BACK);
            air_tatsu_high.Add(3, BMove.HKICK);
            Sequences.Add(air_tatsu_high);
            priorite++;
            #endregion
            #endregion

            #region EX

            #region TATSU EX
            Coup cp_tatsu_ex = new Coup("Tatsu [EX]", priorite, true, false, true);
            priorite++;

            BMoveSequence tatsu_ex_a = new BMoveSequence();
            tatsu_ex_a.Coup = cp_tatsu_ex;
            tatsu_ex_a.Add(0, BMove.DOWN);
            tatsu_ex_a.Add(1, BMove.DOWN_BACK);
            tatsu_ex_a.Add(2, BMove.BACK);
            tatsu_ex_a.Add(3, BMove.HKICK);
            tatsu_ex_a.Add(4, BMove.MKICK);
            Sequences.Add(tatsu_ex_a);

            BMoveSequence tatsu_ex_b = new BMoveSequence();
            tatsu_ex_b.Coup = cp_tatsu_ex;
            tatsu_ex_b.Add(0, BMove.DOWN);
            tatsu_ex_b.Add(1, BMove.DOWN_BACK);
            tatsu_ex_b.Add(2, BMove.BACK);
            tatsu_ex_b.Add(3, BMove.HKICK);
            tatsu_ex_b.Add(3, BMove.LKICK);
            Sequences.Add(tatsu_ex_b);

            BMoveSequence tatsu_ex_c = new BMoveSequence();
            tatsu_ex_c.Coup = cp_tatsu_ex;
            tatsu_ex_c.Add(0, BMove.DOWN);
            tatsu_ex_c.Add(1, BMove.DOWN_BACK);
            tatsu_ex_c.Add(2, BMove.BACK);
            tatsu_ex_c.Add(3, BMove.MKICK);
            tatsu_ex_c.Add(3, BMove.LKICK);
            Sequences.Add(tatsu_ex_c);
            #endregion 
            
            #region AIR TATSU EX
            Coup cp_air_tatsu_ex = new Coup("Tatsu [EX] - Air -", priorite, false, true, false);
            priorite++;

            BMoveSequence air_tatsu_ex_a = new BMoveSequence();
            air_tatsu_ex_a.Coup = cp_air_tatsu_ex;
            air_tatsu_ex_a.Add(0, BMove.DOWN);
            air_tatsu_ex_a.Add(1, BMove.DOWN_BACK);
            air_tatsu_ex_a.Add(2, BMove.BACK);
            air_tatsu_ex_a.Add(3, BMove.HKICK);
            air_tatsu_ex_a.Add(4, BMove.MKICK);
            Sequences.Add(air_tatsu_ex_a);

            BMoveSequence air_tatsu_ex_b = new BMoveSequence();
            air_tatsu_ex_b.Coup = cp_air_tatsu_ex;
            air_tatsu_ex_b.Add(0, BMove.DOWN);
            air_tatsu_ex_b.Add(1, BMove.DOWN_BACK);
            air_tatsu_ex_b.Add(2, BMove.BACK);
            air_tatsu_ex_b.Add(3, BMove.HKICK);
            air_tatsu_ex_b.Add(3, BMove.LKICK);
            Sequences.Add(air_tatsu_ex_b);

            BMoveSequence air_tatsu_ex_c = new BMoveSequence();
            air_tatsu_ex_c.Coup = cp_air_tatsu_ex;
            air_tatsu_ex_c.Add(0, BMove.DOWN);
            air_tatsu_ex_c.Add(1, BMove.DOWN_BACK);
            air_tatsu_ex_c.Add(2, BMove.BACK);
            air_tatsu_ex_c.Add(3, BMove.MKICK);
            air_tatsu_ex_c.Add(3, BMove.LKICK);
            Sequences.Add(air_tatsu_ex_c);
            #endregion 

            #region HADOKEN EX
            Coup cp_hadoken_ex = new Coup("Hadoken [EX]", priorite, true, false, true);
            priorite++;

            BMoveSequence hadoken_ex_a = new BMoveSequence();
            hadoken_ex_a.Coup = cp_hadoken_ex;
            hadoken_ex_a.Add(0, BMove.DOWN);
            hadoken_ex_a.Add(1, BMove.DOWN_FORWARD);
            hadoken_ex_a.Add(2, BMove.FORWARD);
            hadoken_ex_a.Add(3, BMove.HPUNCH);
            hadoken_ex_a.Add(3, BMove.MPUNCH);
            Sequences.Add(hadoken_ex_a);

            BMoveSequence hadoken_ex_b = new BMoveSequence();
            hadoken_ex_b.Coup = cp_hadoken_ex;
            hadoken_ex_b.Add(0, BMove.DOWN);
            hadoken_ex_b.Add(1, BMove.DOWN_FORWARD);
            hadoken_ex_b.Add(2, BMove.FORWARD);
            hadoken_ex_b.Add(3, BMove.HPUNCH);
            hadoken_ex_b.Add(3, BMove.LPUNCH);
            Sequences.Add(hadoken_ex_b);

            BMoveSequence hadoken_ex_c = new BMoveSequence();
            hadoken_ex_c.Coup = cp_hadoken_ex;
            hadoken_ex_c.Add(0, BMove.DOWN);
            hadoken_ex_c.Add(1, BMove.DOWN_FORWARD);
            hadoken_ex_c.Add(2, BMove.FORWARD);
            hadoken_ex_c.Add(3, BMove.MPUNCH);
            hadoken_ex_c.Add(3, BMove.LPUNCH);
            Sequences.Add(hadoken_ex_c);
            #endregion

            #region SHORYUKEN EX
            Coup cp_shoryuken_ex = new Coup("Hadoken [EX]", priorite, true, false, true);
            priorite++;

            BMoveSequence shoryuken_ex_a = new BMoveSequence();
            shoryuken_ex_a.Coup = cp_shoryuken_ex;
            shoryuken_ex_a.Add(0, BMove.FORWARD);
            shoryuken_ex_a.Add(1, BMove.DOWN);
            shoryuken_ex_a.Add(2, BMove.DOWN_FORWARD);
            shoryuken_ex_a.Add(3, BMove.HPUNCH);
            shoryuken_ex_a.Add(3, BMove.MPUNCH);
            Sequences.Add(shoryuken_ex_a);

            BMoveSequence shoryuken_ex_b = new BMoveSequence();
            shoryuken_ex_b.Coup = cp_shoryuken_ex;
            shoryuken_ex_b.Add(0, BMove.FORWARD);
            shoryuken_ex_b.Add(1, BMove.DOWN);
            shoryuken_ex_b.Add(2, BMove.DOWN_FORWARD);
            shoryuken_ex_b.Add(3, BMove.HPUNCH);
            shoryuken_ex_b.Add(3, BMove.LPUNCH);
            Sequences.Add(shoryuken_ex_b);

            BMoveSequence shoryuken_ex_c = new BMoveSequence();
            shoryuken_ex_c.Coup = cp_shoryuken_ex;
            shoryuken_ex_c.Add(0, BMove.FORWARD);
            shoryuken_ex_c.Add(1, BMove.DOWN);
            shoryuken_ex_c.Add(2, BMove.DOWN_FORWARD);
            shoryuken_ex_c.Add(3, BMove.MPUNCH);
            shoryuken_ex_c.Add(3, BMove.LPUNCH);
            Sequences.Add(shoryuken_ex_c);
            #endregion
            
            #endregion

            #region SUPER

            Coup cp_shinkuu_hadoken = new Coup("Shinkuu Hadoken", priorite, true, false, true);
            priorite++;

            BMoveSequence shinkuu_a = new BMoveSequence();
            shinkuu_a.Coup = cp_shinkuu_hadoken;
            shinkuu_a.Add(0, BMove.DOWN);
            shinkuu_a.Add(1, BMove.DOWN_FORWARD);
            shinkuu_a.Add(2, BMove.FORWARD);
            shinkuu_a.Add(3, BMove.DOWN);
            shinkuu_a.Add(4, BMove.DOWN_FORWARD);
            shinkuu_a.Add(5, BMove.FORWARD);
            shinkuu_a.Add(6, BMove.LPUNCH);
            Sequences.Add(shinkuu_a);

            BMoveSequence shinkuu_b = new BMoveSequence();
            shinkuu_b.Coup = cp_shinkuu_hadoken;
            shinkuu_b.Add(0, BMove.DOWN);
            shinkuu_b.Add(1, BMove.DOWN_FORWARD);
            shinkuu_b.Add(2, BMove.FORWARD);
            shinkuu_b.Add(3, BMove.DOWN);
            shinkuu_b.Add(4, BMove.DOWN_FORWARD);
            shinkuu_b.Add(5, BMove.FORWARD);
            shinkuu_b.Add(6, BMove.MPUNCH);
            Sequences.Add(shinkuu_b);

            BMoveSequence shinkuu_c = new BMoveSequence();
            shinkuu_c.Coup = cp_shinkuu_hadoken;
            shinkuu_c.Add(0, BMove.DOWN);
            shinkuu_c.Add(1, BMove.DOWN_FORWARD);
            shinkuu_c.Add(2, BMove.FORWARD);
            shinkuu_c.Add(3, BMove.DOWN);
            shinkuu_c.Add(4, BMove.DOWN_FORWARD);
            shinkuu_c.Add(5, BMove.FORWARD);
            shinkuu_c.Add(6, BMove.HPUNCH);
            Sequences.Add(shinkuu_c);

            #endregion
        }

        public override void Load()
        {
            base.Load();

            
            AnimationData animedepart = getAnimationData_from_AnimationName(AnimationEnCours);
            sprite = new SpriteManager(animedepart.Texture, position, 0, animedepart.NbFrames, animedepart.WidthFrame, animedepart.Origine);
            Sprite.animSimple(animedepart.StartingFrame, animedepart.EndingFrame, animedepart.TempsAnime, animedepart.Loop, animedepart.SensInverse);

        }

        public override void updateAnimation()
        {
            base.updateAnimation();            
            
            switch (State)
            {
                case CharStates.STAND:
                    anime("Stand");
                    break;
                case CharStates.CROUCH:
                    anime("Crouch");
                    break;
                case CharStates.WALKFORWARD:
                    anime("FWalk");
                    break;
                case CharStates.WALKBACK:
                    anime("BWalk");
                    break;
                case CharStates.CROUCHING:
                    if (AnimationEnCours == "Standing")
                        anime("Crouching", Sprite.CurrentFrame);
                    else
                        anime("Crouching");
                    break;
                case CharStates.STANDING:
                    if (AnimationEnCours == "Crouching")
                        anime("Standing", Sprite.CurrentFrame);
                    else
                        anime("Standing");
                    break;
                case CharStates.DASH:
                    anime("Dash");
                    break;
                case CharStates.BACKDASH:
                    anime("Backdash");
                    break;
                case CharStates.UJUMP:
                    anime("UJump");
                    break;
                case CharStates.BJUMP:
                    anime("BJump");
                    break;
                case CharStates.FJUMP:
                    anime("FJump");
                    break;
                default :
                    anime("Stand");
                    break;
            }
        }
        
    }

    public class Guile : Character
    {
        public Guile(ContentManager _ContentManager, Vector2 _pos_depart)
            : base(_ContentManager, _pos_depart)
        {
            name = "Guile";
            Vie_max = 1000;
            Stun_max = 1000;

            Vector2 origineDefaut = new Vector2(137f,191f);

            // Animations
            AnimationList.Add(new AnimationData("Stand", "characters/Remy/sprite_remy_stand", 13, 0, 274, origineDefaut, true, false, 1.09f));
            AnimationEnCours = "Stand"; // Animation par défaut
            // -------------------

            Alive = true;
        }

        public override void Load()
        {
            base.Load();


            AnimationData animedepart = getAnimationData_from_AnimationName(AnimationEnCours);
            sprite = new SpriteManager(animedepart.Texture, position, 0, animedepart.NbFrames, animedepart.WidthFrame, animedepart.Origine);
            Sprite.animSimple(animedepart.StartingFrame, animedepart.EndingFrame, animedepart.TempsAnime, animedepart.Loop, animedepart.SensInverse);

        }

        public override void updateAnimation()
        {
            base.updateAnimation();

            switch (State)
            {
                case CharStates.STAND:
                    anime("Stand");
                    break;
                default:
                    anime("Stand");
                    break;
            }
        }
    }

    public class Zangief : Character
    {
        public Zangief(ContentManager _ContentManager, Vector2 _pos_depart)
            : base(_ContentManager, _pos_depart)
        {
            name = "Zangief";
            Vie_max = 1200;
            Stun_max = 1000;

            Vector2 origineDefaut = new Vector2(145f,186f);

            // Animations
            AnimationList.Add(new AnimationData("Stand", "characters/Hugo/sprite_hugo_stand", 13, 0, 290, origineDefaut, true, false, 1.09f));
            AnimationEnCours = "Stand"; // Animation par défaut
            // -------------------

            Alive = true;



        }

        public override void Load()
        {
            base.Load();


            AnimationData animedepart = getAnimationData_from_AnimationName(AnimationEnCours);
            sprite = new SpriteManager(animedepart.Texture, position, 0, animedepart.NbFrames, animedepart.WidthFrame, animedepart.Origine);
            Sprite.animSimple(animedepart.StartingFrame, animedepart.EndingFrame, animedepart.TempsAnime, animedepart.Loop, animedepart.SensInverse);

        }

        public override void updateAnimation()
        {
            base.updateAnimation();

            switch (State)
            {
                case CharStates.STAND:
                    anime("Stand");
                    break;
                default:
                    anime("Stand");
                    break;
            }
        }
    }
}
